package com.cyj.dream.core.util.collection;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Console;
import lombok.extern.slf4j.Slf4j;

import java.util.*;

/**
 * @Description: 集合工具类
 * @BelongsProject: DreamChardonnay
 * @BelongsPackage: com.cyj.dream.core.util
 * @Author: ChenYongJia
 * @CreateTime: 2021-09-26 11:11
 * @Email: chen87647213@163.com
 * @Version: 1.0
 */
@Slf4j
public class CollectionUtils {

    /**
     * 判断集合是否为空（包括null和没有元素的集合）。
     *
     * @param coll
     * @return
     */
    public static boolean isEmpty(Collection coll) {
        return CollUtil.isEmpty(coll);
    }

    /**
     * 判断集合是否不为空
     *
     * @param coll
     * @return
     */
    public static boolean isNotEmpty(Collection coll) {
        return CollUtil.isNotEmpty(coll);
    }

    /**
     * 根据指定的符号分割 list
     *
     * @param coll
     * @param strings 用什么符号隔开
     * @return
     */
    public static String joinColl(Collection coll, String strings) {
        //str -> a,b,c,d,e 用英文,替换
        return CollUtil.join(coll, strings);
    }

    /**
     * 删除集合中指定值的元素
     *
     * @param coll
     * @return
     */
    public static Collection removeList(Collection coll, Object strings) {
        /**
         * 正常删除，推荐使用（这种方式可以正常的循环及删除。但要注意的是，使用iterator的remove方法）
         */
        for (Iterator<Object> ite = coll.iterator(); ite.hasNext(); ) {
            String str = ite.next().toString();
            if (str.equals(strings.toString())) {
                ite.remove();
            }
        }
        return coll;
    }

    /**
     * 删除集合中包含指定值的元素
     *
     * @param coll
     * @return
     */
    public static Collection removeContainsList(Collection coll, Object strings) {
        /**
         * 正常删除，推荐使用（这种方式可以正常的循环及删除。但要注意的是，使用iterator的remove方法）
         */
        for (Iterator<Object> ite = coll.iterator(); ite.hasNext(); ) {
            String str = ite.next().toString();
            if (str.contains(strings.toString())) {
                ite.remove();
            }
        }
        return coll;
    }

    /**
     * 给定两个集合，然后两个集合中的元素一一对应，成为一个Map
     *
     * @param keys
     * @param values
     * @return
     */
    public static Map<String, Object> removeContainsList(Collection keys, Collection values) {
        return CollUtil.zip(keys, values);
    }

    /**
     * 此方法可以过滤map，排除不需要的key
     *
     * @param map 需要进行拍出的map集合
     * @param inc 排除不需要的key
     * @return
     */
   /* public static Map<String, Object> filterMap(Map<String, Object> map, String[] inc) {
        List<String> incList = Arrays.asList(inc);
        map = CollectionUtil.filter(map, new Editor<Map.Entry<String, Object>>() {
            @Override
            public Map.Entry<String, Object> edit(Map.Entry<String, Object> stringObjectEntry) {
                if (incList.contains(stringObjectEntry.getKey())) {
                    return stringObjectEntry;
                }
                return null;
            }
        });
        log.info("过滤后的map ============>{}", map);
        return map;
    }*/

    /**
     * 模拟调用 hutool 封装的 CollUtil 工具类，且含带自行封装的对 Collection 集合的公共操作
     *
     * @param args
     */
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        CollectionUtils.removeContainsList(list, 3);
        Console.log(list);

        List<String> list2 = new ArrayList<>(Arrays.asList("c1", "cy2", "c3", "cy4", "c5", "cy6", "c7", "cy8", "c9"));
        CollectionUtils.removeList(list2, "cy2");
        Console.log(list2);

        Console.log(CollectionUtils.joinColl(list, "~"));
        Console.log(CollectionUtils.isEmpty(list));
        Console.log(CollectionUtils.isNotEmpty(list));

        Map<String, Object> map = new HashMap<String, Object>(3) {{
            put("k1", "v1");
            put("k2", "v2");
            put("k3", "v3");
        }};
        //需要的key
        String[] inc = {"k1", "k3"};
        //Console.log(CollectionUtils.filterMap(map, inc));
    }

}
